import proj4 from 'proj4';
import {register} from 'ol/proj/proj4'
import { Projection,addProjection} from 'ol/proj';
import TileLayer from 'ol/layer/Tile';
import TileGrid from 'ol/tilegrid/TileGrid';
import VectorTileLayer from 'ol/layer/VectorTile';
import {XYZ} from 'ol/source';
import {TileSuperMapRest} from "@supermap/iclient-ol";
// import {VectorTileSuperMapRest,VectorTileStyles} from "@supermap/iclient-ol";
import {VectorTileStyles} from "@/map/VectorTileStyles";
import {VectorTileSuperMapRest} from "@/map/VectorTileSuperMapRest";

//将4490注册到projection中
proj4.defs("EPSG:4490","GEOGCS[\"China Geodetic Coordinate System 2000\",DATUM[\"China_2000\",SPHEROID[\"CGCS2000\",6378137,298.257222101,AUTHORITY[\"EPSG\",\"1024\"]],AUTHORITY[\"EPSG\",\"1043\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4490\"]]");
register(proj4);

//重写projection4490
let projection = new Projection({
    code: 'EPSG:4490',
    units: 'degrees',
    axisOrientation: 'neu'
});
projection.setExtent([-180, -90, 180, 90]);
projection.setWorldExtent([-180, -90, 180, 90]);
//覆盖添加到projection中
addProjection(projection);

export function getProjection() {
    return projection
}

//地图服务网址
export function iServerHttp(){
    // return "http://10.13.155.192:8090"
    //代理
    return "http://10.7.208.233:8080"
}

//米转度
export function meterToDegree(meter) {
    let degree = meter / (Math.PI * 2 * 6378137 / 360);

    return degree;
}

//度转米
export function degreeToMeter(degree) {
    let meter = degree * (Math.PI * 2 * 6378137 / 360);

    return meter;
}

//自定义比例尺（天地图fxpc）
export function getResolutions() {
    let resolutions = [];
    //MVT 矢量瓦片第0级分辨率为全球范围宽度除以瓦片宽度512.
    //常见坐标系第0级分辨率   WebMercator(3857):2*6378137*Math.PI/512    WGS84(4326):360.0/512    China2000(4490):360.0/512    Beijing54(4214):360.0/512     Xian80(4610):360.0/512
    let topResolution = 360.0 / 512;
    for (let z = 0; z < 18; z++) {
        let resolution = topResolution / Math.pow(2, z);
        resolutions[z] = resolution;
        let dpi = 96;//超图使用，防止图层偏移
        // let dpi = 90.7142857142857;//自定义比例尺
        // let scale = 1 / (resolution / 0.0254 * dpi * (2 * Math.PI * 6378137) / 360);
    }

    return resolutions;
}

function getMatrixIds() {
    let matrixIds = [];
    for (let z = 0; z < 18; ++z) {
        matrixIds[z] = z;
    }
    return matrixIds;
}

//获取tileGrid（自定义比例尺）
export function getTileGrid(origin,extent) {
    return new TileGrid({
        origin: origin,
        extent: extent,
        resolutions: getResolutions(),
        matrixIds: getMatrixIds(),
        tilesSize: [256, 256]
    });
}

//fxpc天地图街道地图底图
export function getTiandituVecMap(){
    return new TileLayer({
        title: '天地图街道地图底图',
        source: new XYZ({
          crossOrigin: 'Anonymous', // 是否请求跨域操作
          url: 'http://t0.tianditu.gov.cn/vec_c/wmts?SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER=vec&STYLE=default&TILEMATRIXSET=c&FORMAT=tiles&TILEMATRIX={z}&TILEROW={y}&TILECOL={x}&tk=0bfd57475542d76f12578a701d2a70ab',
          projection: getProjection()
        })
    });
}

//fxpc天地图街道地图注记
export function getTiandituVecText(){
    return new TileLayer({
        title: '天地图街道地图注记',
        source: new XYZ({
            crossOrigin: 'Anonymous', // 是否请求跨域操作
            url: 'http://t0.tianditu.gov.cn/cva_c/wmts?SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER=cva&STYLE=default&TILEMATRIXSET=c&FORMAT=tiles&TILEMATRIX={z}&TILEROW={y}&TILECOL={x}&tk=0bfd57475542d76f12578a701d2a70ab',
            projection: getProjection()
        })
    });
}

//fxpc天地图卫星影像底图
export function getTiandituImgMap(){
    return new TileLayer({
        title: '天地图卫星影像底图',
        source: new XYZ({
            crossOrigin: 'Anonymous', // 是否请求跨域操作
            url: 'http://t0.tianditu.gov.cn/img_c/wmts?SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER=img&STYLE=default&TILEMATRIXSET=c&FORMAT=tiles&TILEMATRIX={z}&TILEROW={y}&TILECOL={x}&tk=0bfd57475542d76f12578a701d2a70ab',
            projection: getProjection()
        })
    });
}

//fxpc天地图卫星影像注记
export function getTiandituImgText(){
    return new TileLayer({
        title: '天地图卫星影像注记',
        source: new XYZ({
            crossOrigin: 'Anonymous', // 是否请求跨域操作
            url: 'http://t0.tianditu.gov.cn/cia_c/wmts?SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER=cia&STYLE=default&TILEMATRIXSET=c&FORMAT=tiles&TILEMATRIX={z}&TILEROW={y}&TILECOL={x}&tk=0bfd57475542d76f12578a701d2a70ab',
            projection: getProjection()
        })
    });
}

//获取超图发布的REST图层（自定义比例尺）
export function getRESTLayer(layerUrl,layerID,origin,extent,serviceResult,maxZoom) {
    //获取tileGrid（自定义比例尺）
    let tileGrid = getTileGrid(origin,extent);
    if(layerID==null){//临时图层ID
        layerID = "";
    }
    console.log("超图发布的REST图层layerUrl");
    console.log(layerUrl);
    console.log("layerID:"+layerID);
    console.log(origin);
    console.log(extent);
    // let tileOptions = TileSuperMapRest.optionsFromMapJSON(layerUrl, serviceResult);
    //自定义瓦片参数对象
    let tileOptions = {};
    tileOptions.url = layerUrl;
    tileOptions.crossOrigin = 'anonymous';
    tileOptions.tileGrid = tileGrid;
    tileOptions.layersID = layerID;//临时图层ID
    tileOptions.projection = projection;//设置projection4490
    tileOptions.dpi = 96;//超图使用，防止图层偏移
    tileOptions.cacheEnabled = false;//是否使用缓存
    return new TileLayer({
        source: new TileSuperMapRest(tileOptions),
        projection: projection
    });
}

//获取超图发布的REST矢量切片图层（自定义比例尺）
export function getVectorTileLayer(map,layerUrl,origin,extent,view,serviceResult,sqlText,minZoom) {
    //处理sql对象
    let sqlObjArray = [];
    // if(sqlText!=null && sqlText!==""){
    //     let sqlArray = sqlText.split("and");
    //     for(let i=0;i<sqlArray.length;i++){
    //         let sqlStrArr = sqlArray[i].trim().split(" like ");
    //         let fieldProp = sqlStrArr[0];
    //         let fieldValue = sqlStrArr[1];
    //         let sqlObj = {
    //             fieldProp:fieldProp,
    //             fieldValue:fieldValue
    //         }
    //         sqlObjArray.push(sqlObj);
    //     }
    // }
    //test
    sqlObjArray = [{
        fieldProp:"outdoor_num",
        fieldValue:"YJ110"
    }];
    console.log("sqlObjArray");
    console.log(sqlObjArray);
    //矢量瓦片风格参数对象
    let stylesOptions = {
        url: layerUrl,
        view: view
    };
    //创建瓦片风格对象
    let vectorTileStyles = new VectorTileStyles(stylesOptions);
    console.log("vectorTileStyles");
    console.log(vectorTileStyles);
    //通过地图信息获取瓦片参数对象
    // let vectorTileOptions = VectorTileSuperMapRest.optionsFromMapJSON(layerUrl, serviceResult);
    //自定义瓦片参数对象
    let vectorTileOptions = {};
    vectorTileOptions.url = layerUrl;
    vectorTileOptions.crossOrigin = 'anonymous';
    //获取tileGrid（自定义比例尺）
    let tileGrid = getTileGrid(origin,extent);
    vectorTileOptions.tileGrid = tileGrid;
    vectorTileOptions.sqlObjArray = sqlObjArray;//设置sql查询对象数组
    vectorTileOptions.projection = projection;//设置projection4490
    // vectorTileOptions.view = view;
    // vectorTileOptions.minZoom = 10;//最小显示的地图级别
    console.log("vectorTileOptions");
    console.log(vectorTileOptions);
    let source = new VectorTileSuperMapRest(vectorTileOptions);//重写tileUrlFunction、tileLoadFunction（自定义比例尺）
    console.log("source");
    console.log(source);

    //返回超图发布的REST矢量切片图层（自定义比例尺）
    let layer = new VectorTileLayer({
        minZoom:minZoom,
        source: source,
        style: vectorTileStyles.featureStyleFuntion
    });

    return [layer,vectorTileStyles];
}

/*//超图server口令
let serverToken = null;
//获取超图server口令
export function getServerToken(type,layerName){
    if(serverToken==null){
        let dataUrl = iServerHttp()+"/iserver/services/security/tokens.rjson";
        let url = encodeURI(dataUrl);
        let obj = {
            userName:"admin",
            password:"1qaz@WSX",
            clientType:"NONE",//查询数量
            expiration:60,//申请令牌的有效期，从发布令牌的时间开始计算，单位为分钟
        }
        let entry = JSON.stringify(obj);
        console.log(entry);
        let xhr = new XMLHttpRequest();//第一步：建立所需的对象
        xhr.open("POST", url, true);//第二步：打开连接  将请求参数写在url中
        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
        //获取数据后的处理程序
        xhr.onreadystatechange = function(){
            let readyState = xhr.readyState;
            if (readyState == 4){
                let status = xhr.status;
                let responseText =  xhr.responseText;
                if(responseText){
                    serverToken = responseText;//获取超图server口令
                    console.log(type+"--获取超图server口令");
                    if(type=="tif"){
                        //tif发布超图服务工具--创建任务（tif发布）
                        tifMapLayerToolJobPost(layerName);
                    }else if(type=="slopeTif"){
                        //tif发布超图服务工具--创建任务（生成坡度）
                        tifMapLayerToolJobPost2(layerName);
                    }else if(type=="aspectTif"){
                        //tif发布超图服务工具--创建任务（生成坡向）
                        tifMapLayerToolJobPost3(layerName);
                    }else if(type=="clipTif"){
                        let geomText = "MULTIPOLYGON(((100 30,103 30,103 31,102 31,101 30.5,100 30)))";
                        //tif发布超图服务工具--创建任务（栅格裁剪文件）
                        tifMapLayerToolJobPost4(layerName,geomText);
                    }else if(type=="countTif"){
                        layerName = "test_计算_3";
                        let countString = "Con([demtif.test_计算_3] < 0.01, 10, Con([demtif.test_计算_3] < 0.03, 20, Con([demtif.test_计算_3] < 0.09, 30, Con([demtif.test_计算_3] < 0.27, 40, 50))))";
                        //tif发布超图服务工具--创建任务（栅格自定义计算发布）
                        tifMapLayerToolJobPost5(layerName,countString);
                    }else if(type=="maxMinTif"){
                        layerName = "test_计算_3";
                        //tif发布超图服务工具--同步执行处理自动化工具（栅格基本统计-获取最大最小值）
                        tifMapLayerToolJobGet1(layerName);
                    }else if(type=="vectorTif"){
                        layerName = "dzzh_task";//矢量转栅格的数据集
                        let clipLayerName = "dzzh_task";//边界数据集
                        //tif发布超图服务工具--创建任务（矢量过滤转换栅格发布）
                        tifMapLayerToolJobPost6(layerName,clipLayerName);
                    }else if(type=="exportTif"){
                        //tif发布超图服务工具--创建任务（导出tif文件）
                        tifMapLayerToolJobPost7(layerName);
                    }else if(type=="demHslCount"){
                        //tif发布超图服务工具--创建任务（DEM高程计算汇水量a）
                        tifMapLayerToolJobPost8(layerName);
                    }else if(type=="demCdlbCount"){
                        //tif发布超图服务工具--创建任务（DEM高程计算场地类别）
                        tifMapLayerToolJobPost9(layerName);
                    }else if(type=="resetLevelCount"){
                        //tif发布超图服务工具--创建任务（重分类自然分割法发布）
                        tifMapLayerToolJobPost10(layerName);
                    }else if(type=="WorkspaceReload"){
                        let smwuUrl = "C:/Users/lenovo/Desktop/192/MapData/fxfzdzzh/fxfzdzzh10/fxfzdzzh.smwu";
                        let datasource = "fxfzdzzh";
                        let dataset = "dzzh_slide_result_intensity";
                        //刷新指定超图工作空间数据源数据集
                        mapLayerWorkspaceReload(smwuUrl,datasource,dataset);
                    }
                }
                xhr.onreadystatechange = function(){};
                xhr = null;
            }
        };
        xhr.send(entry);//第三步：发送请求  将请求参数写在URL中
    }
}

//tif发布超图服务工具--创建任务（tif发布）
export function tifMapLayerToolJobPost(layerName){
    if(serverToken!=null){
        let dataUrl = iServerHttp()+"/iserver/services/geoprocessing/restjsr/gp/v2/sps.WorkflowProcessFactory.models.tif发布:tif发布/jobs?token="+serverToken;
        let url = encodeURI(dataUrl);
        // let layerName = "tifLayer"+Date.now();
        // let layerName = "坐标转换后的四川dem90米_1683254637249";
        // let layerName = "坡度_1683855831608";
        // let layerName = "坡向_1683855872669";
        layerName = "坐标转换后的四川dem90米_1683254637249";
        let obj = {
            //执行处理自动化工具时的参数设置，形式为{”ParameterID1”:”value1”,”ParameterID2”:”value2”,……}，其中ParameterID为工具的参数ID，由对应的处理自动化工具描述可以确定，value为参数的值
            parameter: {
                "String": "C:/Users/lenovo/Desktop/192/MapData/tif/tif/"+layerName+".tif",//tif文件路径
                "String_1": layerName,//栅格数据集名称
                "String_2": layerName,//栅格图层名称
            },
            //执行处理自动化工具的环境参数设置
            environment:[{
                // type:"",
                // master: "",
                // settings: []
            }]
        }
        let entry = JSON.stringify(obj);
        console.log(entry);
        let xhr = new XMLHttpRequest();//第一步：建立所需的对象
        xhr.open("POST", url, true);//第二步：打开连接  将请求参数写在url中
        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
        //获取数据后的处理程序
        xhr.onreadystatechange = function(){
            let readyState = xhr.readyState;
            if (readyState == 4){
                let status = xhr.status;
                let responseText =  xhr.responseText;
                if(responseText){
                    // {"jobID":"gp-20200909-153236-3E89D","status":"started"}
                    let result = JSON.parse(responseText);
                    let jobID = result.jobID;//返回的要素列表
                    //tif发布超图服务工具--根据ID查询任务信息
                    tifMapLayerToolJobGet(jobID);
                }
                xhr.onreadystatechange = function(){};
                xhr = null;
            }
        };
        xhr.send(entry);//第三步：发送请求  将请求参数写在URL中
    }
}

//tif发布超图服务工具--根据ID查询任务信息
export function tifMapLayerToolJobGet(jobID){
    if(jobID && serverToken){
        let dataUrl = iServerHttp()+"/iserver/services/geoprocessing/restjsr/gp/v2/jobs/"+jobID+".json?token="+serverToken;
        //图层图例信息查询
        let httpRequest = new XMLHttpRequest();//第一步：建立所需的对象
        httpRequest.open('GET', dataUrl, true);//第二步：打开连接  将请求参数写在url中  ps:"http://localhost:8080/rest/xxx"
        httpRequest.send();//第三步：发送请求  将请求参数写在URL中
        /!**
         * 获取数据后的处理程序
         *!/
        httpRequest.onreadystatechange = function () {
            if (httpRequest.readyState == 4 && httpRequest.status == 200) {
                let json = httpRequest.responseText;//获取到json字符串，还需解析
                let obj = JSON.parse(json);
                let progress = obj.progress;
                if(progress.percent==100){
                    //任务完成100%
                }else{
                    setTimeout(function(){
                        tifMapLayerToolJobGet(jobID);
                    },1000);
                }
            }
        };
    }
}

//tif发布超图服务工具--创建任务（生成坡度）
export function tifMapLayerToolJobPost2(layerName){
    if(serverToken!=null){
        let dataUrl = iServerHttp()+"/iserver/services/geoprocessing/restjsr/gp/v2/sps.WorkflowProcessFactory.models.tif发布:生成坡度/jobs?token="+serverToken;
        let url = encodeURI(dataUrl);
        // let layerName = "坡度_1683855831608";
        let obj = {
            //执行处理自动化工具时的参数设置，形式为{”ParameterID1”:”value1”,”ParameterID2”:”value2”,……}，其中ParameterID为工具的参数ID，由对应的处理自动化工具描述可以确定，value为参数的值
            parameter: {
                "String": "坐标转换后的四川dem90米_202305100949_1683683386203",//高程数据集名称
                "String_1": layerName,//坡度数据集名称
                "String_2":"坐标转换后的四川dem90米_轮廓提取_2307081",//高程轮廓提取数据集名
                "String_3":"坡度_坐标转换后的四川dem90米_2307081",//坡度裁剪结果数据集名
                "String_4": "C:/Users/lenovo/Desktop/192/MapData/tif/tif/"+layerName+".tif",//坡度文件路径
            },
            //执行处理自动化工具的环境参数设置
            environment:[{
                // type:"",
                // master: "",
                // settings: []
            }]
        }
        let entry = JSON.stringify(obj);
        console.log(entry);
        let xhr = new XMLHttpRequest();//第一步：建立所需的对象
        xhr.open("POST", url, true);//第二步：打开连接  将请求参数写在url中
        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
        //获取数据后的处理程序
        xhr.onreadystatechange = function(){
            let readyState = xhr.readyState;
            if (readyState == 4){
                let status = xhr.status;
                let responseText =  xhr.responseText;
                if(responseText){
                    // {"jobID":"gp-20200909-153236-3E89D","status":"started"}
                    let result = JSON.parse(responseText);
                    let jobID = result.jobID;//返回的要素列表
                    //tif发布超图服务工具--根据ID查询任务信息
                    tifMapLayerToolJobGet(jobID);
                }
                xhr.onreadystatechange = function(){};
                xhr = null;
            }
        };
        xhr.send(entry);//第三步：发送请求  将请求参数写在URL中
    }
}

//tif发布超图服务工具--创建任务（生成坡向）
export function tifMapLayerToolJobPost3(layerName){
    if(serverToken!=null){
        let dataUrl = iServerHttp()+"/iserver/services/geoprocessing/restjsr/gp/v2/sps.WorkflowProcessFactory.models.tif发布:生成坡向/jobs?token="+serverToken;
        let url = encodeURI(dataUrl);
        // let layerName = "坡向_1683855872669";
        let obj = {
            //执行处理自动化工具时的参数设置，形式为{”ParameterID1”:”value1”,”ParameterID2”:”value2”,……}，其中ParameterID为工具的参数ID，由对应的处理自动化工具描述可以确定，value为参数的值
            parameter: {
                "String": "坐标转换后的四川dem90米_202305100949_1683683386203",//高程数据集名称
                "String_1": layerName,//坡向数据集名称
                "String_2":"坐标转换后的四川dem90米_轮廓提取_2307081",//高程轮廓提取数据集名
                "String_3":"坡向_坐标转换后的四川dem90米_2307081",//坡向裁剪结果数据集名
                "String_4": "C:/Users/lenovo/Desktop/192/MapData/tif/tif/"+layerName+".tif",//坡向文件路径
            },
            //执行处理自动化工具的环境参数设置
            environment:[{
                // type:"",
                // master: "",
                // settings: []
            }]
        }
        let entry = JSON.stringify(obj);
        console.log(entry);
        let xhr = new XMLHttpRequest();//第一步：建立所需的对象
        xhr.open("POST", url, true);//第二步：打开连接  将请求参数写在url中
        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
        //获取数据后的处理程序
        xhr.onreadystatechange = function(){
            let readyState = xhr.readyState;
            if (readyState == 4){
                let status = xhr.status;
                let responseText =  xhr.responseText;
                if(responseText){
                    // {"jobID":"gp-20200909-153236-3E89D","status":"started"}
                    let result = JSON.parse(responseText);
                    let jobID = result.jobID;//返回的要素列表
                    //tif发布超图服务工具--根据ID查询任务信息
                    tifMapLayerToolJobGet(jobID);
                }
                xhr.onreadystatechange = function(){};
                xhr = null;
            }
        };
        xhr.send(entry);//第三步：发送请求  将请求参数写在URL中
    }
}

//tif发布超图服务工具--创建任务（栅格裁剪文件）
export function tifMapLayerToolJobPost4(layerName,geomText){
    if(serverToken!=null){
        let dataUrl = iServerHttp()+"/iserver/services/geoprocessing/restjsr/gp/v2/sps.WorkflowProcessFactory.models.tif发布:面wkt裁剪栅格文件发布/jobs?token="+serverToken;
        let url = encodeURI(dataUrl);
        // let layerName = "坡度_test_2";
        // let geomText = "MULTIPOLYGON(((100 30,103 30,103 31,100 30)))";
        let resultLayerName = layerName + "_裁剪_"+Date.now();//裁剪结果数据集
        let obj = {
            //执行处理自动化工具时的参数设置，形式为{”ParameterID1”:”value1”,”ParameterID2”:”value2”,……}，其中ParameterID为工具的参数ID，由对应的处理自动化工具描述可以确定，value为参数的值
            parameter: {
                "81d2403b-02b5-4735-978b-48724a006e82":layerName,//栅格数据集名称
                "GeoRegion": geomText,//面几何对象wkt
                "52868036-e093-4e1e-9662-db82d7e5b7ab": resultLayerName,//栅格裁剪结果数据集名称
                "64df700f-7c1d-4ff0-8d74-2a5f8114e8e8":32767,//栅格无值
                "7cb39b22-8ee1-48d4-ba0c-9067576e1b10": "C:/Users/lenovo/Desktop/192/MapData/tif/tif/"+resultLayerName+".tif",//栅格裁剪结果文件路径
            },
            //执行处理自动化工具的环境参数设置
            environment:[{
                // type:"",
                // master: "",
                // settings: []
            }]
        }
        let entry = JSON.stringify(obj);
        console.log(entry);
        let xhr = new XMLHttpRequest();//第一步：建立所需的对象
        xhr.open("POST", url, true);//第二步：打开连接  将请求参数写在url中
        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
        //获取数据后的处理程序
        xhr.onreadystatechange = function(){
            let readyState = xhr.readyState;
            if (readyState == 4){
                let status = xhr.status;
                let responseText =  xhr.responseText;
                if(responseText){
                    // {"jobID":"gp-20200909-153236-3E89D","status":"started"}
                    let result = JSON.parse(responseText);
                    let jobID = result.jobID;//返回的要素列表
                    //tif发布超图服务工具--根据ID查询任务信息
                    tifMapLayerToolJobGet(jobID);
                }
                xhr.onreadystatechange = function(){};
                xhr = null;
            }
        };
        xhr.send(entry);//第三步：发送请求  将请求参数写在URL中
    }
}

//tif发布超图服务工具--创建任务（栅格自定义计算发布）
export function tifMapLayerToolJobPost5(layerName,countString){
    if(serverToken!=null){
        let dataUrl = iServerHttp()+"/iserver/services/geoprocessing/restjsr/gp/v2/sps.WorkflowProcessFactory.models.tif发布:栅格计算发布/jobs?token="+serverToken;
        let url = encodeURI(dataUrl);
        // let layerName = "坡度_1685776237313_裁剪_1686034845649";
        let resultLayerName = layerName + "_计算_"+Date.now();//裁剪结果数据集
        let obj = {
            //执行处理自动化工具时的参数设置，形式为{”ParameterID1”:”value1”,”ParameterID2”:”value2”,……}，其中ParameterID为工具的参数ID，由对应的处理自动化工具描述可以确定，value为参数的值
            parameter: {
                "String":countString,//栅格计算表达式
                "String_1": resultLayerName,//计算结果数据集名称
            },
            //执行处理自动化工具的环境参数设置
            environment:[{
                // type:"",
                // master: "",
                // settings: []
            }]
        }
        let entry = JSON.stringify(obj);
        console.log(entry);
        let xhr = new XMLHttpRequest();//第一步：建立所需的对象
        xhr.open("POST", url, true);//第二步：打开连接  将请求参数写在url中
        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
        //获取数据后的处理程序
        xhr.onreadystatechange = function(){
            let readyState = xhr.readyState;
            if (readyState == 4){
                let status = xhr.status;
                let responseText =  xhr.responseText;
                if(responseText){
                    // {"jobID":"gp-20200909-153236-3E89D","status":"started"}
                    let result = JSON.parse(responseText);
                    let jobID = result.jobID;//返回的要素列表
                    //tif发布超图服务工具--根据ID查询任务信息
                    tifMapLayerToolJobGet(jobID);
                }
                xhr.onreadystatechange = function(){};
                xhr = null;
            }
        };
        xhr.send(entry);//第三步：发送请求  将请求参数写在URL中
    }
}

//tif发布超图服务工具--创建任务（矢量过滤转换栅格发布）
export function tifMapLayerToolJobPost6(layerName,clipLayerName){
    if(serverToken!=null){
        let dataUrl = iServerHttp()+"/iserver/services/geoprocessing/restjsr/gp/v2/sps.WorkflowProcessFactory.models.tif发布:矢量过滤转换栅格发布/jobs?token="+serverToken;
        let url = encodeURI(dataUrl);
        // let layerName = "dzzh_task";
        // let clipLayerName = "dzzh_task";
        let timeStamp = Date.now();//时间戳，用于数据集名称后缀，防止重名
        let resultLayerName = layerName + "_矢量转栅格_" + timeStamp;//裁剪结果数据集
        let fieldName = "SmUserID";//用于生成栅格值的矢量数据的字段，默认用超图自身的字段SmUserID值为0
        let resultFilePath = "C:/Users/lenovo/Desktop/192/MapData/tif/tif/"+resultLayerName+".tif";//导出文件路径
        //矢量数据
        let datasetName = layerName;//用于转换栅格的矢量数据集名称
        let tempDatasetName = "temp_" + datasetName + "_" + timeStamp;//矢量过滤临时结果数据集名称
        let sqlFilter = "dt_id!='f93240cd9e90411b9da7f3d604d104ec'";//过滤删除其他数据的表达式，即只保留不符合sql条件的数据
        //边界裁剪
        let datasetNameClip = clipLayerName;//用于转换栅格的边界矢量数据集名称
        let tempDatasetNameClip = "temp_" + datasetNameClip + "_clip_" + timeStamp;//边界矢量过滤临时结果数据集名称
        let sqlFilterClip = "dt_id!='f93240cd9e90411b9da7f3d604d104ec'";//边界过滤删除其他数据的表达式，即只保留不符合sql条件的数据
        let size = 0.0008880937137850466;//单元格大小，即栅格分辨率，可通过读取原栅格数据的分辨率设置，需要将如8.880937137850466E-4的科学记数转成浮点数
        let noDataValue = -9999;//空白区域值，即设置无值
        let obj = {
            //执行处理自动化工具时的参数设置，形式为{”ParameterID1”:”value1”,”ParameterID2”:”value2”,……}，其中ParameterID为工具的参数ID，由对应的处理自动化工具描述可以确定，value为参数的值
            parameter: {
                "String":resultLayerName,//结果数据集名称
                "String_1": fieldName,//字段名称
                "String_2": datasetName,//矢量数据集名称
                "String_3": tempDatasetName,//目标数据集名称
                "String_4": sqlFilter,//SQL删除过滤表达式
                "String_5": datasetNameClip,//边界矢量数据集名称
                "String_6": tempDatasetNameClip,//边界目标数据集名称
                "String_7": sqlFilterClip,//边界SQL删除过滤表达式
                "String_8": resultFilePath,//导出文件路径
                "Double": size,//栅格分辨率
                "Double_1": noDataValue,//空白区域值
            },
            //执行处理自动化工具的环境参数设置
            environment:[{
                // type:"",
                // master: "",
                // settings: []
            }]
        }
        let entry = JSON.stringify(obj);
        console.log(entry);
        let xhr = new XMLHttpRequest();//第一步：建立所需的对象
        xhr.open("POST", url, true);//第二步：打开连接  将请求参数写在url中
        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
        //获取数据后的处理程序
        xhr.onreadystatechange = function(){
            let readyState = xhr.readyState;
            if (readyState == 4){
                let status = xhr.status;
                let responseText =  xhr.responseText;
                if(responseText){
                    // {"jobID":"gp-20200909-153236-3E89D","status":"started"}
                    let result = JSON.parse(responseText);
                    let jobID = result.jobID;//返回的要素列表
                    //tif发布超图服务工具--根据ID查询任务信息
                    tifMapLayerToolJobGet(jobID);
                }
                xhr.onreadystatechange = function(){};
                xhr = null;
            }
        };
        xhr.send(entry);//第三步：发送请求  将请求参数写在URL中
    }
}

//tif发布超图服务工具--创建任务（导出tif文件）
export function tifMapLayerToolJobPost7(layerName){
    if(serverToken!=null){
        let dataUrl = iServerHttp()+"/iserver/services/geoprocessing/restjsr/gp/v2/sps.WorkflowProcessFactory.models.tif发布:导出tif文件/jobs?token="+serverToken;
        let url = encodeURI(dataUrl);
        // let timeStamp = Date.now();//时间戳，用于数据集名称后缀，防止重名
        // let layerName = "dzzh_task_tif_" + timeStamp;
        let filePath = "C:/Users/lenovo/Desktop/192/MapData/tif/tif/"+layerName+".tif";
        let obj = {
            //执行处理自动化工具时的参数设置，形式为{”ParameterID1”:”value1”,”ParameterID2”:”value2”,……}，其中ParameterID为工具的参数ID，由对应的处理自动化工具描述可以确定，value为参数的值
            parameter: {
                "String_1":layerName,//数据集名称
                "String_2": filePath,//导出文件路径
            },
            //执行处理自动化工具的环境参数设置
            environment:[{
                // type:"",
                // master: "",
                // settings: []
            }]
        }
        let entry = JSON.stringify(obj);
        console.log(entry);
        let xhr = new XMLHttpRequest();//第一步：建立所需的对象
        xhr.open("POST", url, true);//第二步：打开连接  将请求参数写在url中
        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
        //获取数据后的处理程序
        xhr.onreadystatechange = function(){
            let readyState = xhr.readyState;
            if (readyState == 4){
                let status = xhr.status;
                let responseText =  xhr.responseText;
                if(responseText){
                    // {"jobID":"gp-20200909-153236-3E89D","status":"started"}
                    let result = JSON.parse(responseText);
                    let jobID = result.jobID;//返回的要素列表
                    //tif发布超图服务工具--根据ID查询任务信息
                    tifMapLayerToolJobGet(jobID);
                }
                xhr.onreadystatechange = function(){};
                xhr = null;
            }
        };
        xhr.send(entry);//第三步：发送请求  将请求参数写在URL中
    }
}

//tif发布超图服务工具--创建任务（DEM高程计算汇水量a）
export function tifMapLayerToolJobPost8(layerName){
    if(serverToken!=null){
        let dataUrl = iServerHttp()+"/iserver/services/geoprocessing/restjsr/gp/v2/sps.WorkflowProcessFactory.models.tif发布:DEM高程计算汇水量a/jobs?token="+serverToken;
        let url = encodeURI(dataUrl);
        let timeStamp = Date.now();//时间戳，用于数据集名称后缀，防止重名
        // let layerName = "高程_四川雅江县_裁剪";
        let layerName2 = "temp_流向_"+timeStamp;
        let layerName3 = "temp_坡度_"+timeStamp;
        let layerName4 = "temp_地形_"+timeStamp;
        let layerName5 = "temp_汇水量_"+timeStamp;//结果数据集名
        let obj = {
            //执行处理自动化工具时的参数设置，形式为{”ParameterID1”:”value1”,”ParameterID2”:”value2”,……}，其中ParameterID为工具的参数ID，由对应的处理自动化工具描述可以确定，value为参数的值
            parameter: {
                "String":layerName,//高程数据集名称
                "String_1": layerName2,//流向栅格数据集名
                "String_2": layerName3,//坡度数据集名称
                "String_3": layerName4,//地形数据集名
                "String_4": layerName5,//结果数据集名
            },
            //执行处理自动化工具的环境参数设置
            environment:[{
                // type:"",
                // master: "",
                // settings: []
            }]
        }
        let entry = JSON.stringify(obj);
        console.log(entry);
        let xhr = new XMLHttpRequest();//第一步：建立所需的对象
        xhr.open("POST", url, true);//第二步：打开连接  将请求参数写在url中
        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
        //获取数据后的处理程序
        xhr.onreadystatechange = function(){
            let readyState = xhr.readyState;
            if (readyState == 4){
                let status = xhr.status;
                let responseText =  xhr.responseText;
                if(responseText){
                    // {"jobID":"gp-20200909-153236-3E89D","status":"started"}
                    let result = JSON.parse(responseText);
                    let jobID = result.jobID;//返回的要素列表
                    //tif发布超图服务工具--根据ID查询任务信息
                    tifMapLayerToolJobGet(jobID);
                }
                xhr.onreadystatechange = function(){};
                xhr = null;
            }
        };
        xhr.send(entry);//第三步：发送请求  将请求参数写在URL中
    }
}

//tif发布超图服务工具--创建任务（DEM高程计算场地类别）
export function tifMapLayerToolJobPost9(layerName){
    if(serverToken!=null){
        let dataUrl = iServerHttp()+"/iserver/services/geoprocessing/restjsr/gp/v2/sps.WorkflowProcessFactory.models.tif发布:DEM高程计算场地类别/jobs?token="+serverToken;
        let url = encodeURI(dataUrl);
        let timeStamp = Date.now();//时间戳，用于数据集名称后缀，防止重名
        // let layerName = "高程_四川雅江县_裁剪";
        let layerName2 = "temp_百分比_坡度_"+timeStamp;
        let layerName3 = "temp_场地类别_"+timeStamp;//结果数据集名
        //通过坡度百分比计算场地类别sql
        let sql = "Con(isNull([demtif."+layerName2+"]),-9999," +
            "Con([demtif."+layerName2+"]<0.01,0," +
            "Con([demtif."+layerName2+"]<1.8,0.751," +
            "Con([demtif."+layerName2+"]<13.8,0.178,0.070))))";
        let obj = {
            //执行处理自动化工具时的参数设置，形式为{”ParameterID1”:”value1”,”ParameterID2”:”value2”,……}，其中ParameterID为工具的参数ID，由对应的处理自动化工具描述可以确定，value为参数的值
            parameter: {
                "String":layerName,//高程数据集名称
                "String_1": layerName2,//坡度数据集名称
                "String_2": sql,//栅格计算表达式
                "String_3": layerName3,//计算结果数据集名称
            },
            //执行处理自动化工具的环境参数设置
            environment:[{
                // type:"",
                // master: "",
                // settings: []
            }]
        }
        let entry = JSON.stringify(obj);
        console.log(entry);
        let xhr = new XMLHttpRequest();//第一步：建立所需的对象
        xhr.open("POST", url, true);//第二步：打开连接  将请求参数写在url中
        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
        //获取数据后的处理程序
        xhr.onreadystatechange = function(){
            let readyState = xhr.readyState;
            if (readyState == 4){
                let status = xhr.status;
                let responseText =  xhr.responseText;
                if(responseText){
                    // {"jobID":"gp-20200909-153236-3E89D","status":"started"}
                    let result = JSON.parse(responseText);
                    let jobID = result.jobID;//返回的要素列表
                    //tif发布超图服务工具--根据ID查询任务信息
                    tifMapLayerToolJobGet(jobID);
                }
                xhr.onreadystatechange = function(){};
                xhr = null;
            }
        };
        xhr.send(entry);//第三步：发送请求  将请求参数写在URL中
    }
}

//tif发布超图服务工具--创建任务（重分类自然分割法发布）
export function tifMapLayerToolJobPost10(layerName){
    if(serverToken!=null){
        let dataUrl = iServerHttp()+"/iserver/services/geoprocessing/restjsr/gp/v2/sps.WorkflowProcessFactory.models.tif发布:重分类自然分割法发布/jobs?token="+serverToken;
        let url = encodeURI(dataUrl);
        let timeStamp = Date.now();//时间戳，用于数据集名称后缀，防止重名
        // let layerName = "高程_四川雅江县_裁剪";
        let layerName2 = "temp_重分类_自然分割_"+timeStamp;//结果数据集名
        let obj = {
            //执行处理自动化工具时的参数设置，形式为{”ParameterID1”:”value1”,”ParameterID2”:”value2”,……}，其中ParameterID为工具的参数ID，由对应的处理自动化工具描述可以确定，value为参数的值
            parameter: {
                "String":layerName,//栅格数据集名称
                "Integer": 5,//区域数量
                "Integer_1": 0,//最低区域的值
                "String_1": layerName2,//结果数据名称
                // "String_2": "C:/Users/lenovo/Desktop/192/MapData/模板/重分类自然分割法图层模板.xml",//图层模板
            },
            //执行处理自动化工具的环境参数设置
            environment:[{
                // type:"",
                // master: "",
                // settings: []
            }]
        }
        let entry = JSON.stringify(obj);
        console.log(entry);
        let xhr = new XMLHttpRequest();//第一步：建立所需的对象
        xhr.open("POST", url, true);//第二步：打开连接  将请求参数写在url中
        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
        //获取数据后的处理程序
        xhr.onreadystatechange = function(){
            let readyState = xhr.readyState;
            if (readyState == 4){
                let status = xhr.status;
                let responseText =  xhr.responseText;
                if(responseText){
                    // {"jobID":"gp-20200909-153236-3E89D","status":"started"}
                    let result = JSON.parse(responseText);
                    let jobID = result.jobID;//返回的要素列表
                    //tif发布超图服务工具--根据ID查询任务信息
                    tifMapLayerToolJobGet(jobID);
                }
                xhr.onreadystatechange = function(){};
                xhr = null;
            }
        };
        xhr.send(entry);//第三步：发送请求  将请求参数写在URL中
    }
}

//tif发布超图服务工具--同步执行处理自动化工具（栅格基本统计-获取最大最小值）
export function tifMapLayerToolJobGet1(layerName){
    if(serverToken!=null){
        let dataUrl = iServerHttp()+"/iserver/services/geoprocessing/restjsr/gp/v2/sps.WorkflowProcessFactory.models.tif发布:栅格基本统计/execute?token="+serverToken;
        let url = encodeURI(dataUrl);
        let obj = {
            //执行处理自动化工具时的参数设置，形式为{”ParameterID1”:”value1”,”ParameterID2”:”value2”,……}，其中ParameterID为工具的参数ID，由对应的处理自动化工具描述可以确定，value为参数的值
            parameter: {
                "String":layerName,//栅格数据集名称
            },
            //执行处理自动化工具的环境参数设置
            environment:[{
                // type:"",
                // master: "",
                // settings: []
            }]
        }
        let entry = JSON.stringify(obj);
        console.log(entry);
        let xhr = new XMLHttpRequest();//第一步：建立所需的对象
        xhr.open("GET", url, true);//第二步：打开连接  将请求参数写在url中
        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
        //获取数据后的处理程序
        xhr.onreadystatechange = function(){
            let readyState = xhr.readyState;
            if (readyState == 4){
                let status = xhr.status;
                let responseText =  xhr.responseText;
                console.log("栅格基本统计-获取最大最小值");
                console.log(responseText);
                if(responseText){
                    // {"basicstatistics-basicStatisticsAnalystResult":"{\"gridHistogram\":null,\"basicStatisticsAnalystResult\":{\"max\":20.0,\"mean\":13.171640644209491,\"min\":10.0,\"thirdQuartile\":20.0,\"skewness\":0.7857626517588212,\"kurtosis\":1.617422944899055,\"median\":10.0,\"firstQuartile\":10.0,\"standardDeviation\":4.653720356877553}}"}
                    let result = JSON.parse(responseText);
                    console.log(result);
                    let countResult = JSON.parse(result["basicstatistics-basicStatisticsAnalystResult"]);//返回的统计结果
                    console.log(countResult);
                    if(countResult){
                        let basicStatisticsAnalystResult = countResult["basicStatisticsAnalystResult"];
                        if(basicStatisticsAnalystResult){
                            let max = basicStatisticsAnalystResult.max;
                            let min = basicStatisticsAnalystResult.min;
                            console.log(max+","+min);
                        }
                    }
                }
                xhr.onreadystatechange = function(){};
                xhr = null;
            }
        };
        xhr.send(entry);//第三步：发送请求  将请求参数写在URL中
    }
}

//刷新指定超图工作空间数据源数据集
export function mapLayerWorkspaceReload(smwuUrl,datasource,dataset){
    if(serverToken!=null){
        let dataUrl = iServerHttp()+"/iserver/manager/workspaces/workspacereload.rjson?token="+serverToken;
        let url = encodeURI(dataUrl);
        smwuUrl = "C:/Users/lenovo/Desktop/192/MapData/fxfzdzzh/fxfzdzzh10/fxfzdzzh.smwu";
        datasource = "fxfzdzzh";
        dataset = "dzzh_slide_result_intensity";
        let obj = {
            //刷新指定数据源数据集时的参数设置，形式为{"workspaceConnectionInfo":"C:/Users/lenovo/Desktop/192/MapData/fxfzdzzh/fxfzdzzh10/fxfzdzzh.smwu","isForce":true,"datasets":{"fxfzdzzh":["dzzh_slide_result_intensity"]}}
            workspaceConnectionInfo: smwuUrl,
            //表示是否强制刷新。如果为 false 则只有当数据源发生变化时才刷新，数据源没有变化时不进行刷新；为 true 时，不论数据源是否变化，均会强制刷新。
            isForce:true,
            datasets:{"fxfzdzzh":[dataset]}
        }
        console.log("刷新指定超图工作空间数据源数据集");
        console.log(obj);
        let entry = JSON.stringify(obj);
        console.log(entry);
        let xhr = new XMLHttpRequest();//第一步：建立所需的对象
        xhr.open("POST", url, true);//第二步：打开连接  将请求参数写在url中
        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
        //获取数据后的处理程序
        xhr.onreadystatechange = function(){
            let readyState = xhr.readyState;
            if (readyState == 4){
                let status = xhr.status;
                let responseText =  xhr.responseText;
                if(responseText){
                    let result = JSON.parse(responseText);
                    let succeed = result.succeed;//表示是否刷新成功
                    if(succeed){
                        //刷新成功
                    }
                }
                xhr.onreadystatechange = function(){};
                xhr = null;
            }
        };
        xhr.send(entry);//第三步：发送请求  将请求参数写在URL中
    }
}*/
